home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 2 / Meeting Pearls Vol. II (1995)(GTI - Schatztruhe)[!].iso / Pearls / comm / Envoy / Conf / tk.c < prev    next >
C/C++ Source or Header  |  1994-04-22  |  35KB  |  744 lines
  1. /*************************************************************************
  2.  
  3. Conference Server/Service written by Jeffrey A. Litz
  4.  
  5. litz@cs.uwp.edu  -or-  Jeff_Litz@EDTNG.Kenosha.WI.US
  6.  
  7. Copyright ©1994 JL Productions.
  8. *************************************************************************/
  9.  
  10.  
  11. #include <exec/types.h>
  12. #include <exec/memory.h>
  13. #include <exec/ports.h>
  14. #include <exec/semaphores.h>
  15. #include <exec/io.h>
  16. #include <devices/printer.h>
  17. #include <devices/timer.h>
  18. #include <devices/parallel.h>
  19. #include <devices/serial.h>
  20.  
  21. #include <intuition/intuition.h>
  22. #include <intuition/classes.h>
  23. #include <intuition/classusr.h>
  24. #include <intuition/imageclass.h>
  25. #include <intuition/gadgetclass.h>
  26. #include <libraries/gadtools.h>
  27. #include <graphics/displayinfo.h>
  28. #include <graphics/gfxbase.h>
  29. #include <clib/intuition_protos.h>
  30. #include <clib/gadtools_protos.h>
  31. #include <clib/graphics_protos.h>
  32.  
  33. #include <envoy/nipc.h>
  34. #include <envoy/services.h>
  35. #include <proto/intuition.h>
  36.  
  37. #include <pragmas/exec_pragmas.h>
  38. #include <pragmas/nipc_pragmas.h>
  39. #include <pragmas/dos_pragmas.h>
  40. #include <pragmas/utility_pragmas.h>
  41.  
  42. #include <utility/tagitem.h>
  43. #include <clib/dos_protos.h>
  44. #include <clib/exec_protos.h>
  45. #include <clib/nipc_protos.h>
  46. #include <clib/alib_protos.h>
  47. #include <clib/utility_protos.h>
  48.  
  49. #include "string.h"
  50.  
  51. extern KPrintF(STRPTR,...);
  52.  
  53.  
  54.  
  55.  
  56. /*************************************************************************
  57. Some structures & definitions for the conference service.
  58. Should go into a .h file.
  59. *************************************************************************/
  60. #include "tkbase.h"
  61.  
  62. #define TKCMD_TALK         1
  63. #define TKCMD_ABORT        2
  64. #define TKCMD_DATA         3
  65. #define TKCMD_CONFERENCE   4
  66. #define TKCMD_CONDATA      5
  67. #define TKCMD_CONEND       6
  68. #define TKCMD_CONLIST      7   
  69. #define TKCMD_CLDATA       8
  70. #define TKCMD_CLEND        9
  71. #define TKCMD_MALIST       10
  72. #define TKCMD_STATUS       11
  73. #define TKCMD_PRIVATE      12
  74.  
  75. struct Con_Node
  76. {
  77.    struct Node cnode;
  78.    UBYTE con_name[32];
  79.    struct List machine_list;
  80.    ULONG flags;
  81. };
  82.  
  83. struct Hide_Node
  84. {
  85.    struct Node hnode;
  86.    UBYTE h_name[32];
  87.    ULONG mode;
  88. };
  89.    
  90. struct Machine_Node
  91. {
  92.    struct Node mnode;
  93.    UBYTE m_id[8];
  94.    UBYTE m_name[32];
  95.    UBYTE alias[32];
  96.    struct List hide_list;   
  97.    ULONG flags;
  98.    void *s_entity;
  99. };
  100.  
  101. struct TagItem cbtags[2] =
  102. {
  103.     ENT_AllocSignal, NULL,
  104.     TAG_END, 0
  105. };
  106.  
  107. struct TagItem ttags[3] =
  108. {
  109.     TRN_AllocReqBuffer,516,
  110.     TRN_AllocRespBuffer,4,
  111.     TAG_END, 0
  112. };
  113.  
  114.  
  115. extern  STRPTR       TKSUser;
  116. extern  STRPTR       TKSPassword;
  117. extern  STRPTR       TKSEntityName;
  118. extern  ULONG        TKSSignalMask;
  119. extern  ULONG        TKSError;
  120. extern  struct Task *TKSSMProc;
  121. extern  TKSServer(void);
  122.  
  123. extern struct Node *CFindName(struct List *cc_list,UBYTE *string);
  124.  
  125.  
  126.  
  127.  
  128. /**************************************************************************
  129. StartService() - Starts the service.
  130.  
  131.     Services Manager calls this function to attempt to start the service.
  132.  
  133.     INPUTS: TagList passed in by Services Manager
  134.     OUTPUT: Error Code - Non Zero Means Error
  135. **************************************************************************/
  136. ULONG __saveds ASM StartService(REG(a0) struct TagItem *st_list)
  137. {
  138.     struct TagItem cptags[3];
  139.     struct Process *lpdproc;
  140.     BOOL   status = FALSE;
  141.     UBYTE  sigbit;
  142.     struct TagItem *tag;
  143.     
  144.     
  145.     /* Check to see if service is already open */
  146.     
  147.     if(!TKSBase->TKS_Entity)
  148.     {
  149.         /* Nope - Try starting it up */
  150.         
  151.         if(sigbit = AllocSignal(-1L))
  152.         {
  153.             TKSSMProc = FindTask(0L);
  154.             TKSSignalMask = (1L<<sigbit);
  155.  
  156.             cptags[0].ti_Tag  = NP_Entry;
  157.             cptags[0].ti_Data = (ULONG) TKSServer;
  158.             cptags[1].ti_Tag  = NP_Name;
  159.             cptags[1].ti_Data = (ULONG) "CF Daemon";
  160.             cptags[2].ti_Tag  = TAG_DONE;
  161.             cptags[2].ti_Data = NULL;
  162.         
  163.  
  164.             /* Process tags passed in by services manager */
  165.             
  166.             if(tag=FindTagItem(SSVC_UserName,st_list))
  167.             {
  168.                 TKSUser = (STRPTR) tag->ti_Data;
  169.             }
  170.  
  171.             if(tag=FindTagItem(SSVC_Password,st_list))
  172.             {
  173.                 TKSPassword = (STRPTR) tag->ti_Data;
  174.             }
  175.             
  176.             if(tag=FindTagItem(SSVC_EntityName,st_list))
  177.             {
  178.                 TKSEntityName = (STRPTR) tag->ti_Data;
  179.             }
  180.             
  181.             
  182.             /* Try to start the process */
  183.             
  184.             if(lpdproc = CreateNewProc((struct TagItem *)cptags))
  185.             {
  186.                 Wait(1L<<sigbit);
  187.                 status = TRUE;
  188.             }
  189.             FreeSignal(sigbit);
  190.         }
  191.     }
  192.     else
  193.     {
  194.         /* Service process already running... simply pass back its entity name */
  195.         
  196.         if(tag=FindTagItem(SSVC_EntityName,st_list))
  197.         {
  198.             strcpy((STRPTR)tag->ti_Data,"CF_Service");
  199.             TKSError = 0;
  200.         } else
  201.         {
  202.             TKSError = -1;
  203.         }
  204.     }
  205.     return(TKSError);
  206. }
  207.  
  208.  
  209.  
  210.  
  211. /*************************************************************************
  212. GetServiceAttrsA() - Get service attributes
  213.  
  214.     Required to return the name of the service in tag SVCAttrs_Name
  215.  
  216.     INPUTS: TagList from services manager to process/update
  217. *************************************************************************/
  218. VOID ASM GetServiceAttrsA(REG(a0) struct TagItem *tagList)
  219. {
  220.     struct TagItem *ti;
  221.  
  222.     if(ti=FindTagItem( SVCAttrs_Name, tagList))
  223.     {
  224.         strcpy((STRPTR)ti->ti_Data,"Conf_Service");
  225.     }
  226. }
  227.  
  228.  
  229.  
  230.  
  231. /**************************************************************************
  232. Server() - Actual guts of the service
  233.  
  234.     The Conference Service Main Routine.  Keeps track of all conferences,
  235.     who in them, the "status" of each user, etc.
  236.  
  237.     Waits for any incoming transcation from our public entity.
  238.     
  239.     Called by an ASM stub called TKSServer.
  240.  
  241.     INPUTS: A0 - UserName, A1 - Password, A2 - EntityName
  242.     OUTPUT: Global Var TKSError (only if a startup error occurs)
  243. **************************************************************************/
  244. VOID ASM Server(REG(a0) STRPTR userName,
  245.                 REG(a1) STRPTR password,
  246.                 REG(a2) STRPTR EntityName)
  247. {
  248.     /* Quite a few variables - should be corrected with allocmen() */
  249.  
  250.     struct Library *SvcBase;
  251.     ULONG CON_ID;
  252.     ULONG signals;
  253.     ULONG waitmask;
  254.     ULONG StartupError;
  255.     ULONG ent_sigbit;
  256.     UBYTE host_name[256];
  257.     UBYTE con_name[256],hos_name[256],machine_id[256],alias[256],machine_name[256];
  258.     UBYTE pri_msg[512];
  259.     UBYTE done;
  260.     UWORD cnt;
  261.     ULONG mem_p,error,cycle_mode;
  262.     void *entity,*t_entity,*s_entity;
  263.     struct Transaction *trans,*a_trans;
  264.     struct List conference_list;
  265.     struct Con_Node *c_node,*c_node2;
  266.     struct Machine_Node *m_node,*m2_node,*mm_node,*m_node2;
  267.     struct Hide_Node *m3_node,*m4_node;
  268.     struct Hide_Node *h_node,*h_node2;
  269.     struct TagItem cetags[4];
  270.  
  271.     ULONG m3mode,m4mode;
  272.         
  273.  
  274.     /* Initialize a bunch of things */
  275.     
  276.     geta4();
  277.     
  278.     cetags[0].ti_Tag  = ENT_Name;
  279.     cetags[0].ti_Data = (ULONG) "CF_Service";
  280.     cetags[1].ti_Tag  = ENT_Public;
  281.     cetags[1].ti_Data = (ULONG) TRUE;
  282.     cetags[2].ti_Tag  = ENT_AllocSignal;
  283.     cetags[2].ti_Data = (ULONG) &ent_sigbit;
  284.     cetags[3].ti_Tag  = TAG_END;
  285.     cetags[3].ti_Data = (ULONG) NULL;
  286.     
  287.     ent_sigbit = 0;
  288.     CON_ID = 0;
  289.  
  290.     NewList(&conference_list);
  291.  
  292.     StartupError = -1;
  293.    
  294.  
  295.     /* Start of service */
  296.  
  297.     if(SvcBase = OpenLibrary("conf.service", 0L))
  298.     {
  299.         /* Create our entity for everyone to communicate with us */
  300.         
  301.         if(entity = CreateEntityA((struct TagItem *) cetags))
  302.         {
  303.             /* Find out who we are */
  304.             
  305.             GetHostName(entity,host_name,255);
  306.             
  307.             if(t_entity=CreateEntityA((struct TagItem *) cbtags))
  308.             {
  309.                 /* Alloc our transaction */
  310.                 
  311.                 if(a_trans=AllocTransactionA((struct TagItem *) ttags))
  312.                 {
  313.                     /* Everything allocated - setup and signal we are ready */
  314.                     
  315.                     TKSBase->TKS_Entity = entity;
  316.                     strcpy(EntityName,"CF_Service");
  317.  
  318.                     TKSError = StartupError = 0;
  319.  
  320.                     Signal(TKSSMProc, TKSSignalMask);
  321.                     waitmask = (1<<ent_sigbit);
  322.                     done = 0;
  323.                     
  324.                     
  325.                     /* Wait for a transaction */
  326.                           
  327.                     while(TRUE)
  328.                     {
  329.                         signals = Wait(waitmask);
  330.                         if(signals & (1<<ent_sigbit))
  331.                         {
  332.                             if(trans = GetTransaction(entity))
  333.                             {
  334.                                 /* Process a TKCMD_CONFERENCE Transaction */
  335.                                 /* Create or enter a conference           */
  336.                                 
  337.                                 if(trans->trans_Command == TKCMD_CONFERENCE)
  338.                                 {
  339.                                     error=1;
  340.                                     strcpy(con_name,(UBYTE *)trans->trans_RequestData+4);
  341.                                     strcpy(hos_name,(UBYTE *)trans->trans_RequestData+36);
  342.                                     strcpy(alias,(UBYTE *)trans->trans_RequestData+68);
  343.                                     if(s_entity = FindEntity(hos_name,con_name,t_entity,NULL))
  344.                                     {
  345.                                         if(c_node=(struct Con_Node *)CFindName(&conference_list,con_name))
  346.                                         {
  347.                                             if(!CFindName(&c_node->machine_list,hos_name))
  348.                                             {                                
  349.                                                 if(m_node=AllocMem(sizeof(struct Machine_Node),0))
  350.                                                 {
  351.                                                     strcpy(m_node->m_name,hos_name);
  352.                                                     strcpy(m_node->alias,alias);
  353.                                                     m_node->mnode.ln_Name=m_node->m_id;
  354.                                                     m_node->flags=0;
  355.                                                     m_node->s_entity=s_entity;
  356.                                                     NewList(&m_node->hide_list);
  357.                                                     sprintf(m_node->m_id,"%ld",CON_ID);
  358.                                                     AddTail(&c_node->machine_list,(struct Node *)m_node);
  359.                                                     error=0;
  360.                                                 }
  361.                                             }
  362.                                         }
  363.                                         else
  364.                                         {
  365.                                             if(c_node=(struct Con_Node *)AllocMem(sizeof(struct Con_Node),0))
  366.                                             {
  367.                                                 strcpy(c_node->con_name,con_name);
  368.                                                 c_node->cnode.ln_Name=c_node->con_name;
  369.                                                 c_node->flags=0;
  370.                                                 NewList(&c_node->machine_list);
  371.                                                 if(m_node=(struct Machine_Node *)AllocMem(sizeof(struct Machine_Node),0))
  372.                                                 {
  373.                                                     strcpy(m_node->m_name,hos_name);
  374.                                                     strcpy(m_node->alias,alias);
  375.                                                     m_node->mnode.ln_Name=m_node->m_id;
  376.                                                     m_node->flags=0;
  377.                                                     m_node->s_entity=s_entity;
  378.                                                     NewList(&m_node->hide_list);
  379.                                                     sprintf(m_node->m_id,"%ld",CON_ID);
  380.                                                     AddTail(&c_node->machine_list,(struct Node *)m_node);
  381.                                                     AddTail(&conference_list,(struct Node *)c_node);
  382.                                                     error=0;
  383.                                                 }
  384.                                                 else
  385.                                                 {
  386.                                                     FreeMem(c_node,sizeof(struct Con_Node));
  387.                                                 }
  388.                                             }
  389.                                         }
  390.                                     }
  391.                                     trans->trans_Error=error;
  392.                                     trans->trans_RespDataActual=4;
  393.                                     *(ULONG *)trans->trans_ResponseData=(ULONG) CON_ID;
  394.                                     ReplyTransaction(trans);
  395.  
  396.                                     ++CON_ID;
  397.                                 }
  398.                                 else if(trans->trans_Command == TKCMD_CONDATA)
  399.                                 {
  400.                                     /* Process a TKCMD_CONDATA Transaction */
  401.                                     /* Go through list and distribute data to appropriate machines */
  402.                            
  403.                                     *(ULONG *)(a_trans->trans_RequestData)=*(ULONG *)(trans->trans_RequestData);
  404.                                     strcpy(((UBYTE *)a_trans->trans_RequestData+4),((UBYTE *)trans->trans_RequestData+4));
  405.                                     a_trans->trans_ReqDataActual=strlen(((UBYTE *)a_trans->trans_RequestData+4))+5;
  406.                                     a_trans->trans_Command=TKCMD_CONDATA;
  407.                                     sprintf(machine_id,"%ld",*(ULONG *)trans->trans_RequestData);
  408.                                     ReplyTransaction(trans);
  409.  
  410.                                     for(c_node=(struct Con_Node *)conference_list.lh_Head;c_node->cnode.ln_Succ;c_node=(struct Con_Node *)c_node->cnode.ln_Succ)
  411.                                     {
  412.                                         if(m_node=(struct Machine_Node *)CFindName(&c_node->machine_list,machine_id))
  413.                                         {
  414.                                             for(m2_node=(struct Machine_Node *)c_node->machine_list.lh_Head;m2_node->mnode.ln_Succ;m2_node=(struct Machine_Node *)m2_node->mnode.ln_Succ)
  415.                                             {
  416.                                                 if(stricmp(machine_id,m2_node->m_id))
  417.                                                 {   
  418.                                                     /* Find the node pointer to another machine in the conference */
  419.  
  420.                                                     if( m3_node = (struct Hide_Node *) CFindName(&m_node->hide_list,m2_node->m_name))
  421.                                 {
  422.                                                         m3mode=m3_node->mode;
  423.                                                     } else
  424.                                                     {
  425.                                                         m3mode=0;
  426.                                                     }
  427.  
  428.                                                     /* Find the node pointer to the machine sending the message */
  429.  
  430.                                                     if(m4_node=(struct Hide_Node *)CFindName(&m2_node->hide_list,m_node->m_name))
  431.                                                     {
  432.                                                         m4mode=m4_node->mode;
  433.                                                     } else
  434.                                                     {
  435.                                                         m4mode=0;
  436.                                                     }
  437.  
  438.                                                     if( ((m3mode==0) && ((m4mode==0) || (m4mode==1))) || ((m3mode==2) && ((m4mode==0) || (m4mode==1))))
  439.                                                     {
  440.                                                         cnt=2;
  441.                             while(cnt)
  442.                             {
  443.                                                             a_trans->trans_Timeout=10;
  444.                                 DoTransaction(m2_node->s_entity,t_entity,a_trans);
  445.                                                             if(a_trans->trans_Error == 0)
  446.                                                             {
  447.                                                                 break;
  448.                                                             }
  449.                                                             --cnt;
  450.                                                         }
  451.                                                         if(!cnt)
  452.                                                         {
  453.                                                             /* The machine being sent to couldn't be found - remove it!!! */
  454.                                     
  455.                                                             for(c_node2=(struct Con_Node *)conference_list.lh_Head;c_node2->cnode.ln_Succ;c_node2=(struct Con_Node *)c_node2->cnode.ln_Succ)
  456.                                                             {
  457.                                                                 if(m_node2=(struct Machine_Node *)CFindName(&c_node2->machine_list,m2_node->m_id))
  458.                                                                 {
  459.                                                                     Remove((struct Node*)m_node2);
  460.                                                                     LoseEntity(m_node2->s_entity);
  461.                                                                     while(h_node2=(struct Hide_Node *)RemHead(&m_node2->hide_list))
  462.                                                                     {
  463.                                                                         FreeMem(h_node2,sizeof(struct Hide_Node));
  464.                                                                     } 
  465.                                                                     FreeMem(m_node2,sizeof(struct Machine_Node));
  466.                                                                     if(c_node2->machine_list.lh_Head->ln_Succ == NULL)
  467.                                                                     {
  468.                                                                         Remove((struct Node *)c_node2);
  469.                                                                         FreeMem(c_node2,sizeof(struct Con_Node));
  470.                                                                     }
  471.                                                                     break;
  472.                                                                 }
  473.                                                             }
  474.                                                         }
  475.                                                     }
  476.                                                 }
  477.                                             }
  478.                                             break;
  479.                                         }
  480.                                     }
  481.                                 }
  482.                                 else if(trans->trans_Command == TKCMD_CONEND)
  483.                                 {
  484.                                     /* Process a TKCMD_CONEND transaction */
  485.                                     /* Leave a conference and remove if last member */
  486.                                     
  487.                                     sprintf(machine_id,"%ld",*((ULONG *)trans->trans_RequestData));
  488.                                     for(c_node=(struct Con_Node *)conference_list.lh_Head;c_node->cnode.ln_Succ;c_node=(struct Con_Node *)c_node->cnode.ln_Succ)
  489.                                     {
  490.                                         if(m_node=(struct Machine_Node *)CFindName(&c_node->machine_list,machine_id))
  491.                                         {
  492.                                             Remove((struct Node*)m_node);
  493.                                             LoseEntity(m_node->s_entity);
  494.                                             while(h_node=(struct Hide_Node *)RemHead(&m_node->hide_list))
  495.                                             {
  496.                                                 FreeMem(h_node,sizeof(struct Hide_Node));
  497.                                             }
  498.                                             FreeMem(m_node,sizeof(struct Machine_Node));
  499.                                             if(c_node->machine_list.lh_Head->ln_Succ == NULL)
  500.                                             {
  501.                                                 Remove((struct Node *)c_node);
  502.                                                 FreeMem(c_node,sizeof(struct Con_Node));
  503.                                             }
  504.                                             break;
  505.                                         }
  506.                                     }
  507.                                     ReplyTransaction(trans);
  508.                                 }
  509.                                 else if(trans->trans_Command == TKCMD_CONLIST)
  510.                                 {
  511.                                     /* Return a list of available conferences */
  512.                                     
  513.                                     strcpy(hos_name,(UBYTE *)trans->trans_RequestData+4);
  514.                                     s_entity = FindEntity(hos_name,"Conference_List",t_entity,NULL);
  515.  
  516.                                     if(s_entity)
  517.                                     {
  518.                                         trans->trans_Error=0;
  519.                                         ReplyTransaction(trans);
  520.                                         
  521.                                         mem_p=4;
  522.                                         for(c_node=(struct Con_Node *)conference_list.lh_Head;c_node->cnode.ln_Succ;c_node=(struct Con_Node *)c_node->cnode.ln_Succ)
  523.                                         { 
  524.                                             strcpy(((UBYTE *)a_trans->trans_RequestData+mem_p),c_node->con_name);
  525.                                             mem_p+=32;
  526.                                             if(mem_p == 516)
  527.                                             {
  528.                                                 a_trans->trans_ReqDataActual=516;
  529.                                                 a_trans->trans_Command=TKCMD_CLDATA;
  530.                                                 a_trans->trans_Timeout=10;
  531.                                                 DoTransaction(s_entity,t_entity,a_trans);
  532.                                                 mem_p=4;
  533.                                             }
  534.                                         }
  535.                                         if(mem_p != 4)
  536.                                         {
  537.                                             a_trans->trans_ReqDataActual=mem_p;
  538.                                             a_trans->trans_Command=TKCMD_CLDATA;
  539.                                             a_trans->trans_Timeout=10;
  540.                                             DoTransaction(s_entity,t_entity,a_trans);
  541.                                         }
  542.                                         a_trans->trans_ReqDataActual=4;
  543.                                         a_trans->trans_Command=TKCMD_CLEND;
  544.                                         a_trans->trans_Timeout=10;
  545.                                         DoTransaction(s_entity,t_entity,a_trans);
  546.                                         LoseEntity(s_entity);
  547.                                     } else
  548.                                     {
  549.                                         trans->trans_Error=999;
  550.                                         ReplyTransaction(trans);
  551.                                     }
  552.                                 }
  553.                                 else if(trans->trans_Command == TKCMD_MALIST)
  554.                                 {
  555.                                     /* Return a list of members in a conference */
  556.                                     
  557.                                     strcpy(con_name,(UBYTE *)trans->trans_RequestData+4);
  558.                                     strcpy(hos_name,(UBYTE *)trans->trans_RequestData+36);
  559.  
  560.                                     s_entity = FindEntity(hos_name,"Conference_List",t_entity,NULL);
  561.                                     
  562.                                     if(s_entity)
  563.                                     {
  564.                                         trans->trans_Error=0;
  565.                                         ReplyTransaction(trans);
  566.  
  567.                                         mem_p=4;
  568.                                         if(c_node=(struct Con_Node *)CFindName(&conference_list,con_name))
  569.                                         {
  570.                                             for(m_node=(struct Machine_Node *)c_node->machine_list.lh_Head;m_node->mnode.ln_Succ;m_node=(struct Machine_Node *)m_node->mnode.ln_Succ)
  571.                                             {
  572.                                                 strcpy(((UBYTE *)a_trans->trans_RequestData+mem_p),m_node->m_name);
  573.                                                 strcpy(((UBYTE *)a_trans->trans_RequestData+mem_p+32),m_node->alias);
  574.                                                 
  575.                                                 cycle_mode=0;
  576.                                                 for(mm_node=(struct Machine_Node *)c_node->machine_list.lh_Head;mm_node->mnode.ln_Succ;mm_node=(struct Machine_Node *)mm_node->mnode.ln_Succ)
  577.                                                 {
  578.                                                     if(!stricmp(mm_node->m_name,hos_name))
  579.                                                     {
  580.                                                         if(h_node=(struct Hide_Node *)CFindName(&mm_node->hide_list,m_node->m_name))
  581.                                                         {
  582.                                                             cycle_mode=h_node->mode;
  583.                                                             break;
  584.                                                         }
  585.                                                     }
  586.                                                 }
  587.                                                 *(ULONG *)((UBYTE *)a_trans->trans_RequestData+mem_p+64)=(ULONG)cycle_mode;
  588.                                                 
  589.                                                 mem_p+=68;
  590.                                                 if(mem_p == 480)
  591.                                                 {
  592.                                                     a_trans->trans_ReqDataActual=480;
  593.                                                     a_trans->trans_Command=TKCMD_CLDATA;
  594.                                                     a_trans->trans_Timeout=10;
  595.                                                     DoTransaction(s_entity,t_entity,a_trans);
  596.                                                     mem_p=4;
  597.                                                 }
  598.                                             }
  599.                                             if(mem_p != 4)
  600.                                             {
  601.                                                 a_trans->trans_ReqDataActual=mem_p;
  602.                                                 a_trans->trans_Command=TKCMD_CLDATA;
  603.                                                 a_trans->trans_Timeout=10;
  604.                                                 DoTransaction(s_entity,t_entity,a_trans);
  605.                                             }
  606.                                         }
  607.                                         a_trans->trans_ReqDataActual=4;
  608.                                         a_trans->trans_Command=TKCMD_CLEND;
  609.                                         a_trans->trans_Timeout=10;
  610.                                         DoTransaction(s_entity,t_entity,a_trans);
  611.                                         LoseEntity(s_entity);
  612.                                     } else
  613.                                     {
  614.                                         trans->trans_Error=999;
  615.                                         ReplyTransaction(trans);
  616.                                     }
  617.                                 }
  618.                                 else if(trans->trans_Command == TKCMD_PRIVATE)
  619.                                 {
  620.                                     /* Transmit a private message to a member in x conference on y machine */
  621.                                     
  622.                                     strcpy(hos_name,(UBYTE *)trans->trans_RequestData+4);
  623.                                     strcpy(con_name,(UBYTE *)trans->trans_RequestData+36);
  624.                                     strcpy(pri_msg,(UBYTE *)trans->trans_RequestData+68);
  625.                            
  626.                                     *(ULONG *)(a_trans->trans_RequestData)=*(ULONG *)(trans->trans_RequestData);
  627.                                     strcpy(((UBYTE *)a_trans->trans_RequestData+4),((UBYTE *)trans->trans_RequestData+68));
  628.                                     a_trans->trans_ReqDataActual=strlen(((UBYTE *)a_trans->trans_RequestData+4))+5;
  629.                                     a_trans->trans_Command=TKCMD_CONDATA;
  630.                                     ReplyTransaction(trans);
  631.  
  632.                                     if(c_node=(struct Con_Node *)CFindName(&conference_list,con_name))
  633.                                     {
  634.                                         for(m_node=(struct Machine_Node *)c_node->machine_list.lh_Head;m_node->mnode.ln_Succ;m_node=(struct Machine_Node *)m_node->mnode.ln_Succ)
  635.                                         {
  636.                                             if(!stricmp(m_node->m_name,hos_name))
  637.                                             {
  638.                                                 a_trans->trans_Timeout=10;
  639.                                                 DoTransaction(m_node->s_entity,t_entity,a_trans);
  640.                                                 break;
  641.                                             }
  642.                                         }
  643.                                     }
  644.                                 }
  645.                                 else if(trans->trans_Command == TKCMD_STATUS)
  646.                                 {
  647.                                     /* Change the status of a member in someone's list */
  648.                                     
  649.                                     strcpy(machine_name,(UBYTE *)trans->trans_RequestData+4);
  650.                                     strcpy(con_name,(UBYTE *)trans->trans_RequestData+36);
  651.                                     strcpy(hos_name,(UBYTE *)trans->trans_RequestData+68);
  652.                                     cycle_mode=*(ULONG *)((UBYTE *)trans->trans_RequestData+100);
  653.                        
  654.                                     error=1;
  655.                                     if(c_node=(struct Con_Node *)CFindName(&conference_list,con_name))
  656.                                     {
  657.                                         for(m_node=(struct Machine_Node *)c_node->machine_list.lh_Head;m_node->mnode.ln_Succ;m_node=(struct Machine_Node *)m_node->mnode.ln_Succ)
  658.                                         {
  659.                                             if(!stricmp(m_node->m_name,hos_name))
  660.                                             {
  661.                                                 error=0;
  662.                                                 if(h_node=(struct Hide_Node *)CFindName(&m_node->hide_list,machine_name))
  663.                                                 {
  664.                                                     h_node->mode=cycle_mode;
  665.                                                 }
  666.                                                 else if(h_node=(struct Hide_Node *)AllocMem(sizeof(struct Hide_Node),0))
  667.                                                 {
  668.                                                     h_node->hnode.ln_Name=h_node->h_name;
  669.                                                     strcpy(h_node->h_name,machine_name);
  670.                                                     h_node->mode=cycle_mode;
  671.                                                     AddTail(&m_node->hide_list,(struct Node *)h_node);
  672.                                                 }
  673.                                                 else
  674.                                                 {
  675.                                                     error=1;
  676.                                                 }
  677.                                             }
  678.                                         }
  679.                                     }
  680.                                     trans->trans_Error=error;
  681.                                     ReplyTransaction(trans);
  682.                                 }
  683.                                 if(conference_list.lh_Head->ln_Succ == NULL)
  684.                                 {
  685.                                     done=1;
  686.                                 }
  687.                             }
  688.                         }
  689.                         if(done)
  690.                         {
  691.                             break;
  692.                         }
  693.                     }
  694.                     while(trans = GetTransaction(entity))
  695.                     {
  696.                         trans->trans_Error=2;
  697.                         ReplyTransaction(trans);
  698.                     }                     
  699.  
  700.                     TKSBase->TKS_Entity = NULL;
  701.  
  702.                     a_trans->trans_ReqDataLength=516;
  703.                     FreeTransaction(a_trans);
  704.                 }
  705.                 DeleteEntity(t_entity);
  706.             }
  707.             DeleteEntity(entity);
  708.         }
  709.         if(StartupError) 
  710.         {
  711.             TKSError = StartupError;
  712.             Signal(TKSSMProc, TKSSignalMask);
  713.         }
  714.         Forbid();        
  715.         CloseLibrary(SvcBase);
  716.     }
  717. }
  718.  
  719.  
  720.  
  721.  
  722. /*************************************************************************
  723. CFindName()
  724.  
  725.     Since FindName() is case sensitive, I can't use it...
  726.  
  727.     INPUTS: pointer to a list, pointer to a string to search for
  728.     OUTPUT: NULL if not found, otherwise pointer to that node
  729. *************************************************************************/
  730. struct Node *CFindName(struct List *cc_list,UBYTE *string)
  731. {
  732.    struct Node *r_value=NULL,*ln;
  733.    
  734.    for(ln=cc_list->lh_Head;ln->ln_Succ;ln=ln->ln_Succ)
  735.    {
  736.       if(!stricmp(ln->ln_Name,string))
  737.       {
  738.          r_value=ln;
  739.          break;
  740.       }
  741.    }
  742.    return(r_value);
  743. }
  744.